home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2005 June (DVD) / DPPRO0605DVD.iso / Install / program files / Borland / BDS / 3.0 / Demos / Delphi.Net / VCL / Lexer / mwDelphiLexer.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  2004-10-22  |  25.6 KB  |  842 lines
  1. {-----------------------------------------------------------------------------
  2. This Software is placed into Publlic Domain and distributed on an "AS IS" basis,
  3. WITHOUT WARRANTY OF ANY KIND, either express or implied.
  4. The Initial Developer is Martin Waldenburg
  5. (Martin.Waldenburg@T-Online.de).
  6. -----------------------------------------------------------------------------}
  7. unit mwDelphiLexer;
  8.  
  9. interface
  10.  
  11. uses
  12.   SysUtils, Classes,
  13.   mwLanguageElements, mwBaseLexer, mwSimpleLexer, mwDelphiLanguageElements;
  14.  
  15. type
  16.  
  17.   TmwDelphiRange = (
  18.     drNormal,
  19.     drAnsiDirective,
  20.     drBorlandDirective,
  21.     drAnsiComment,
  22.     drAssemblerReference,
  23.     drBorlandComment
  24.     );
  25.  
  26.   TmwDelphiLexData = class(TmwLexData)
  27.   public
  28.     Range: TmwDelphiRange;
  29.   end;
  30.  
  31.   TmwDelphiLexer = class(TmwSimpleLexer)
  32.   protected
  33.     DirectiveKeyList: TmwLexKeyList;
  34.     procedure CreateKeyLists; override;
  35.     procedure DestroyKeyLists; override;
  36.     procedure InitializeKeyTables; override;
  37.     procedure IdentifierHandler; override;
  38.     procedure AsteriskHandler; override;
  39.     procedure SharpHandler; override;
  40.     procedure DollarHandler; override;
  41.     procedure ApostropheHandler; override;
  42.     procedure RoundOpenHandler; override;
  43.     procedure PeriodHandler; override;
  44.     procedure SlashHandler; override;
  45.     procedure ColonHandler; override;
  46.     procedure LessHandler; override;
  47.     procedure GreaterHandler; override;
  48.     procedure AtHandler; override;
  49.     procedure CurlyOpenHandler; override;
  50.     procedure CurlyCloseHandler; override;
  51.     procedure NextAnsiComment; virtual;
  52.     procedure NextAssemblerReference; virtual;
  53.     procedure NextBorlandComment; virtual;
  54.   public
  55.     Range: TmwDelphiRange;
  56.     procedure AssignData(Source: TmwDelphiLexData); reintroduce;
  57.     procedure AssignToData(Dest: TmwDelphiLexData); reintroduce;
  58.     procedure AnsiCommentHandler; virtual;
  59.     procedure AnsiDirectiveHandler; virtual;
  60.     procedure AssemblerReferenceHandler; virtual;
  61.     procedure BorlandCommentHandler; virtual;
  62.     procedure BorlandDirectiveHandler; virtual;
  63.     procedure Next; override;
  64.   end;
  65.  
  66. implementation
  67.  
  68. { TmwDelphiLexer }
  69.  
  70. procedure TmwDelphiLexer.AnsiCommentHandler;
  71. begin
  72.   Id := leAnsiComment;
  73.   while Run < TheEnd do
  74.   begin
  75.     case Buf[Run] of
  76.       #10: Exit;
  77.  
  78.       #13:
  79.         case (Run + 1 < TheEnd) and (Buf[Run + 1] = #10) of
  80.           True: Exit;
  81.           False: inc(Run);
  82.         end;
  83.  
  84.       '*':
  85.         case (Run + 1 < TheEnd) and (Buf[Run + 1] = ')') of
  86.           True:
  87.             begin
  88.               inc(Run, 2);
  89.               Range := drNormal;
  90.               Exit;
  91.             end;
  92.           False: inc(Run);
  93.         end;
  94.     else
  95.       case Run + UTF8Width[Buf[Run]] < TheEnd of
  96.         True: inc(Run, UTF8Width[Buf[Run]]);
  97.         False: inc(Run);
  98.       end;
  99.     end;
  100.   end;
  101. end;
  102.  
  103. procedure TmwDelphiLexer.AnsiDirectiveHandler;
  104. begin
  105.   Id := leAnsiDirective;
  106.   while Run < TheEnd do
  107.   begin
  108.     case Buf[Run] of
  109.       #10: Exit;
  110.  
  111.       #13:
  112.         case (Run + 1 < TheEnd) and (Buf[Run + 1] = #10) of
  113.           True: Exit;
  114.           False: inc(Run);
  115.         end;
  116.  
  117.       '*':
  118.         case (Run + 1 < TheEnd) and (Buf[Run + 1] = ')') of
  119.           True:
  120.             begin
  121.               inc(Run, 2);
  122.               Range := drNormal;
  123.               Exit;
  124.             end;
  125.           False: inc(Run);
  126.         end;
  127.     else
  128.       case Run + UTF8Width[Buf[Run]] < TheEnd of
  129.         True: inc(Run, UTF8Width[Buf[Run]]);
  130.         False: inc(Run);
  131.       end;
  132.     end;
  133.   end;
  134. end;
  135.  
  136. procedure TmwDelphiLexer.ApostropheHandler;
  137. begin
  138.   inc(Run);
  139.   Id := leUnterminatedStringConstant;
  140.   while Run < TheEnd do
  141.     case Buf[Run] of
  142.       #10, #13: Break;
  143.       #39:
  144.         begin
  145.           inc(Run);
  146.           case Run < TheEnd of
  147.             True:
  148.               case Buf[Run] = #39 of
  149.                 True: inc(Run);
  150.                 False:
  151.                   begin
  152.                     Id := leStringConstant;
  153.                     Break;
  154.                   end;
  155.               end;
  156.             False:
  157.               begin
  158.                 Id := leStringConstant;
  159.                 Break;
  160.               end;
  161.           end;
  162.         end;
  163.     else inc(Run)
  164.     end;
  165. end;
  166.  
  167. procedure TmwDelphiLexer.AssemblerReferenceHandler;
  168. begin
  169.   Id := leAssemblerReference;
  170.   while Run < TheEnd do
  171.   begin
  172.     case Buf[Run] of
  173.       #10: Exit;
  174.  
  175.       #13:
  176.         case (Run + 1 < TheEnd) and (Buf[Run + 1] = #10) of
  177.           True: Exit;
  178.           False: inc(Run);
  179.         end;
  180.  
  181.       '}':
  182.         begin
  183.           inc(Run);
  184.           Range := drNormal;
  185.           Exit;
  186.         end;
  187.     else
  188.       case Run + UTF8Width[Buf[Run]] < TheEnd of
  189.         True: inc(Run, UTF8Width[Buf[Run]]);
  190.         False: inc(Run);
  191.       end;
  192.     end;
  193.   end;
  194. end;
  195.  
  196. procedure TmwDelphiLexer.AssignData(Source: TmwDelphiLexData);
  197. begin
  198.   if (Source <> nil) then
  199.   begin
  200.     ExId := Source.ExId;
  201.     FileName := Source.FileName;
  202.     Id := Source.Id;
  203.     fLinePosition := Source.LinePosition;
  204.     fLineNumber := Source.LineNumber;
  205.     Buf := Source.Buf;
  206.     Range := Source.Range;
  207.     Run := Source.Run;
  208.     Start := Source.Start;
  209.     TheEnd := Source.TheEnd;
  210.   end;
  211. end;
  212.  
  213. procedure TmwDelphiLexer.AssignToData(Dest: TmwDelphiLexData);
  214. begin
  215.   if (Dest <> nil) then
  216.   begin
  217.     Dest.ExId := ExId;
  218.     Dest.FileName := FileName;
  219.     Dest.Id := Id;
  220.     Dest.LinePosition := LinePosition;
  221.     Dest.LineNumber := LineNumber;
  222.     Dest.Buf := Buf;
  223.     Dest.Range := Range;
  224.     Dest.Run := Run;
  225.     Dest.Start := Start;
  226.     Dest.TheEnd := TheEnd;
  227.   end;
  228. end;
  229.  
  230. procedure TmwDelphiLexer.AsteriskHandler;
  231. begin
  232.   inc(Run);
  233.   Id := leAsterisk;
  234.   if Range in [drAnsiComment, drAnsiDirective] then
  235.     if Run < TheEnd then
  236.       if Buf[Run] = ')' then
  237.       begin
  238.         inc(Run);
  239.         Id := leEndOfAnsiComment;
  240.         Range := drNormal;
  241.       end;
  242. end;
  243.  
  244. procedure TmwDelphiLexer.AtHandler;
  245. begin
  246.   inc(Run);
  247.   Id := leAt;
  248.   if (Run < TheEnd) and (Buf[Run] = '@') then
  249.   begin
  250.     Id := leDoubleAt;
  251.     inc(Run);
  252.   end;
  253. end;
  254.  
  255. procedure TmwDelphiLexer.BorlandCommentHandler;
  256. begin
  257.   Id := leBorlandComment;
  258.   while Run < TheEnd do
  259.   begin
  260.     case Buf[Run] of
  261.       #10: Exit;
  262.  
  263.       #13:
  264.         case (Run + 1 < TheEnd) and (Buf[Run + 1] = #10) of
  265.           True: Exit;
  266.           False: inc(Run);
  267.         end;
  268.  
  269.       '}':
  270.         begin
  271.           inc(Run);
  272.           Range := drNormal;
  273.           Exit;
  274.         end;
  275.     else
  276.       case Run + UTF8Width[Buf[Run]] < TheEnd of
  277.         True: inc(Run, UTF8Width[Buf[Run]]);
  278.         False: inc(Run);
  279.       end;
  280.     end;
  281.   end;
  282. end;
  283.  
  284. procedure TmwDelphiLexer.BorlandDirectiveHandler;
  285. begin
  286.   Id := leBorlandDirective;
  287.   while Run < TheEnd do
  288.   begin
  289.     case Buf[Run] of
  290.       #10: Exit;
  291.  
  292.       #13:
  293.         case (Run + 1 < TheEnd) and (Buf[Run + 1] = #10) of
  294.           True: Exit;
  295.           False: inc(Run);
  296.         end;
  297.  
  298.       '}':
  299.         begin
  300.           inc(Run);
  301.           Range := drNormal;
  302.           Exit;
  303.         end;
  304.     else
  305.       case Run + UTF8Width[Buf[Run]] < TheEnd of
  306.         True: inc(Run, UTF8Width[Buf[Run]]);
  307.         False: inc(Run);
  308.       end;
  309.     end;
  310.   end;
  311. end;
  312.  
  313. procedure TmwDelphiLexer.ColonHandler;
  314. begin
  315.   inc(Run);
  316.   Id := leColon;
  317.   if (Run < TheEnd) and (Buf[Run] = '=') then
  318.   begin
  319.     Id := leAssignment;
  320.     inc(Run);
  321.   end;
  322. end;
  323.  
  324. procedure TmwDelphiLexer.CreateKeyLists;
  325. begin
  326.   KeyList := TmwLexKeyList.Create(Self);
  327.   DirectiveKeyList := TmwLexKeyList.Create(Self);
  328. end;
  329.  
  330. procedure TmwDelphiLexer.CurlyCloseHandler;
  331. begin
  332.   inc(Run);
  333.   Id := leCurlyClose;
  334.   if Range in [drBorlandComment, drBorlandDirective] then
  335.     Range := drNormal;
  336. end;
  337.  
  338. procedure TmwDelphiLexer.CurlyOpenHandler;
  339. begin
  340.   inc(Run);
  341.   Id := leCurlyOpen;
  342.   if Range = drNormal then
  343.     case Run < TheEnd of
  344.       True:
  345.         case Buf[Run] of
  346.           '$':
  347.             begin
  348.               inc(Run);
  349.               Id := leBeginOfBorlandDirective;
  350.               Range := drBorlandDirective;
  351.             end;
  352.           '%':
  353.             begin
  354.               inc(Run);
  355.               Id := leAssemblerReference;
  356.               Range := drAssemblerReference;
  357.               AssemblerReferenceHandler;
  358.             end;
  359.         else
  360.           begin
  361.             Range := drBorlandComment;
  362.             BorlandCommentHandler;
  363.           end;
  364.         end;
  365.       False:
  366.         begin
  367.           Range := drBorlandComment;
  368.           BorlandCommentHandler;
  369.         end;
  370.     end;
  371. end;
  372.  
  373. procedure TmwDelphiLexer.DestroyKeyLists;
  374. begin
  375.   KeyList.Free;
  376.   DirectiveKeyList.Free;
  377. end;
  378.  
  379. procedure TmwDelphiLexer.DollarHandler;
  380. begin
  381.   inc(Run);
  382.   Id := leDollar;
  383.   if (Run < TheEnd) and
  384.     ((Buf[Run] >= '0') and (Buf[Run] <= '9')) or
  385.     ((Buf[Run] >= 'a') and (Buf[Run] <= 'f')) or
  386.     ((Buf[Run] >= 'A') and (Buf[Run] <= 'F')) then
  387.   begin
  388.     inc(Run);
  389.     Id := leHexNumber;
  390.     while (Run < TheEnd) and
  391.       ((Buf[Run] >= '0') and (Buf[Run] <= '9')) or
  392.       ((Buf[Run] >= 'a') and (Buf[Run] <= 'f')) or
  393.       ((Buf[Run] >= 'A') and (Buf[Run] <= 'F')) do
  394.       inc(Run);
  395.   end;
  396. end;
  397.  
  398. procedure TmwDelphiLexer.GreaterHandler;
  399. begin
  400.   inc(Run);
  401.   Id := leGreater;
  402.   if (Run < TheEnd) and (Buf[Run] = '=') then
  403.   begin
  404.     Id := leGreaterOrEqual;
  405.     inc(Run);
  406.   end;
  407. end;
  408.  
  409. procedure TmwDelphiLexer.IdentifierHandler;
  410. begin
  411.   inc(Run);
  412.   Id := leIdentifier;
  413.   ExId := leIdentifier;
  414.   while (Run < TheEnd) do
  415.     case InIdentifiers[Buf[Run]] of
  416.       True: inc(Run);
  417.       False: Break;
  418.     end;
  419.   case InInternationalIdentifiers[Buf[Run]] of
  420.     True: InternationalIdentifierHandler;
  421.     False:
  422.       case (Run + 1 < TheEnd) and (Buf[Run] > #191) of
  423.         True: UTF8IdentifierHandler;
  424.       else
  425.         case Range of
  426.           drNormal: KeyList.Hash(Start);
  427.           drAnsiDirective: DirectiveKeyList.Hash(Start);
  428.           drBorlandDirective: DirectiveKeyList.Hash(Start);
  429.         end;
  430.       end;
  431.   end;
  432. end;
  433.  
  434. procedure TmwDelphiLexer.InitializeKeyTables;
  435. begin
  436.   KeyList.Insensitive := True;
  437.   DirectiveKeyList.Insensitive := True;
  438.  
  439.   {KeyWords}
  440.   KeyList.Add('And', leAnd, leDelphiKeyWord);
  441.   KeyList.Add('Array', leArray, leDelphiKeyWord);
  442.   KeyList.Add('As', leAs, leDelphiKeyWord);
  443.   KeyList.Add('Asm', leAsm, leDelphiKeyWord);
  444.   KeyList.Add('Begin', leBegin, leDelphiKeyWord);
  445.   KeyList.Add('Case', leCase, leDelphiKeyWord);
  446.   KeyList.Add('Class', leClass, leDelphiKeyWord);
  447.   KeyList.Add('Const', leConst, leDelphiKeyWord);
  448.   KeyList.Add('Constructor', leConstructor, leDelphiKeyWord);
  449.   KeyList.Add('Destructor', leDestructor, leDelphiKeyWord);
  450.   KeyList.Add('Dispinterface', leDispinterface, leDelphiKeyWord);
  451.   KeyList.Add('Div', leDiv, leDelphiKeyWord);
  452.   KeyList.Add('Do', leDo, leDelphiKeyWord);
  453.   KeyList.Add('Downto', leDownto, leDelphiKeyWord);
  454.   KeyList.Add('Else', leElse, leDelphiKeyWord);
  455.   KeyList.Add('End', leEnd, leDelphiKeyWord);
  456.   KeyList.Add('Except', leExcept, leDelphiKeyWord);
  457.   KeyList.Add('Exports', leExports, leDelphiKeyWord);
  458.   KeyList.Add('File', leFile, leDelphiKeyWord);
  459.   KeyList.Add('Final', leFinal, leDelphiKeyWord);
  460.   KeyList.Add('Finalization', leFinalization, leDelphiKeyWord);
  461.   KeyList.Add('Finally', leFinally, leDelphiKeyWord);
  462.   KeyList.Add('For', leFor, leDelphiKeyWord);
  463.   KeyList.Add('Function', leFunction, leDelphiKeyWord);
  464.   KeyList.Add('Goto', leGoto, leDelphiKeyWord);
  465.   KeyList.Add('If', leIf, leDelphiKeyWord);
  466.   KeyList.Add('Implementation', leImplementation, leDelphiKeyWord);
  467.   KeyList.Add('In', leIn, leDelphiKeyWord);
  468.   KeyList.Add('Inherited', leInherited, leDelphiKeyWord);
  469.   KeyList.Add('Initialization', leInitialization, leDelphiKeyWord);
  470.   KeyList.Add('Inline', leInline, leDelphiKeyWord);
  471.   KeyList.Add('Interface', leInterface, leDelphiKeyWord);
  472.   KeyList.Add('Is', leIs, leDelphiKeyWord);
  473.   KeyList.Add('Label', leLabel, leDelphiKeyWord);
  474.   KeyList.Add('Library', leLibrary, leDelphiDirective);
  475.   KeyList.Add('Mod', leMod, leDelphiKeyWord);
  476.   KeyList.Add('Nil', leNil, leDelphiKeyWord);
  477.   KeyList.Add('Not', leNot, leDelphiKeyWord);
  478.   KeyList.Add('Object', leObject, leDelphiKeyWord);
  479.   KeyList.Add('Of', leOf, leDelphiKeyWord);
  480.   KeyList.Add('Or', leOr, leDelphiKeyWord);
  481.   KeyList.Add('Packed', lePacked, leDelphiKeyWord);
  482.   KeyList.Add('Procedure', leProcedure, leDelphiKeyWord);
  483.   KeyList.Add('Program', leProgram, leDelphiKeyWord);
  484.   KeyList.Add('Property', leProperty, leDelphiKeyWord);
  485.   KeyList.Add('Raise', leRaise, leDelphiKeyWord);
  486.   KeyList.Add('Record', leRecord, leDelphiKeyWord);
  487.   KeyList.Add('Repeat', leRepeat, leDelphiKeyWord);
  488.   KeyList.Add('Resourcestring', leResourcestring, leDelphiKeyWord);
  489.   KeyList.Add('Sealed', leSealed, leDelphiKeyWord);
  490.   KeyList.Add('Set', leSet, leDelphiKeyWord);
  491.   KeyList.Add('Shl', leShl, leDelphiKeyWord);
  492.   KeyList.Add('Shr', leShr, leDelphiKeyWord);
  493.   KeyList.Add('String', leString, leDelphiKeyWord);
  494.   KeyList.Add('Then', leThen, leDelphiKeyWord);
  495.   KeyList.Add('Threadvar', leThreadvar, leDelphiKeyWord);
  496.   KeyList.Add('To', leTo, leDelphiKeyWord);
  497.   KeyList.Add('Try', leTry, leDelphiKeyWord);
  498.   KeyList.Add('Type', leType, leDelphiKeyWord);
  499.   KeyList.Add('Unit', leUnit, leDelphiKeyWord);
  500.   KeyList.Add('Until', leUntil, leDelphiKeyWord);
  501.   KeyList.Add('Uses', leUses, leDelphiKeyWord);
  502.   KeyList.Add('Var', leVar, leDelphiKeyWord);
  503.   KeyList.Add('While', leWhile, leDelphiKeyWord);
  504.   KeyList.Add('With', leWith, leDelphiKeyWord);
  505.   KeyList.Add('Xor', leXor, leDelphiKeyWord);
  506.  
  507.   {Directives}
  508.   KeyList.Add('Absolute', leIdentifier, leAbsolute);
  509.   KeyList.Add('Abstract', leIdentifier, leAbstract);
  510.   KeyList.Add('Assembler', leIdentifier, leAssembler);
  511.   KeyList.Add('At', leIdentifier, leAt);
  512.   KeyList.Add('Automated', leIdentifier, leAutomated);
  513.   KeyList.Add('Cdecl', leIdentifier, leCdecl);
  514.   KeyList.Add('Contains', leIdentifier, leContains);
  515.   KeyList.Add('Default', leIdentifier, leDefault);
  516.   KeyList.Add('Deprecated', leIdentifier, leDeprecated);
  517.   KeyList.Add('Dispid', leIdentifier, leDispid);
  518.   KeyList.Add('Dynamic', leIdentifier, leDynamic);
  519.   KeyList.Add('Experimental', leIdentifier, leExperimental);
  520.   KeyList.Add('Export', leIdentifier, leExport);
  521.   KeyList.Add('External', leIdentifier, leExternal);
  522.   KeyList.Add('Far', leIdentifier, leFar);
  523.   KeyList.Add('Forward', leIdentifier, leForward);
  524.   KeyList.Add('Helper', leIdentifier, leHelper);
  525.   KeyList.Add('Implements', leIdentifier, leImplements);
  526.   KeyList.Add('Index', leIdentifier, leIndex);
  527.   KeyList.Add('Local', leIdentifier, leLocal);
  528.   KeyList.Add('Message', leIdentifier, leMessage);
  529.   KeyList.Add('Name', leIdentifier, leName);
  530.   KeyList.Add('Near', leIdentifier, leNear);
  531.   KeyList.Add('Nodefault', leIdentifier, leNodefault);
  532.   KeyList.Add('On', leIdentifier, leOn);
  533.   KeyList.Add('Out', leIdentifier, leOut);
  534.   KeyList.Add('Overload', leIdentifier, leOverload);
  535.   KeyList.Add('Override', leIdentifier, leOverride);
  536.   KeyList.Add('Package', leIdentifier, lePackage);
  537.   KeyList.Add('Pascal', leIdentifier, lePascal);
  538.   KeyList.Add('Platform', leIdentifier, lePlatform);
  539.   KeyList.Add('Private', leIdentifier, lePrivate);
  540.   KeyList.Add('Protected', leIdentifier, leProtected);
  541.   KeyList.Add('Public', leIdentifier, lePublic);
  542.   KeyList.Add('Published', leIdentifier, lePublished);
  543.   KeyList.Add('Read', leIdentifier, leRead);
  544.   KeyList.Add('Readonly', leIdentifier, leReadonly);
  545.   KeyList.Add('Register', leIdentifier, leRegister);
  546.   KeyList.Add('Reintroduce', leIdentifier, leReintroduce);
  547.   KeyList.Add('Requires', leIdentifier, leRequires);
  548.   KeyList.Add('Resident', leIdentifier, leResident);
  549.   KeyList.Add('Safecall', leIdentifier, leSafecall);
  550.   KeyList.Add('Stdcall', leIdentifier, leStdcall);
  551.   KeyList.Add('Stored', leIdentifier, leStored);
  552.   KeyList.Add('Strict', leIdentifier, leStrict);
  553.   KeyList.Add('Varargs', leIdentifier, leVarargs);
  554.   KeyList.Add('Virtual', leIdentifier, leVirtual);
  555.   KeyList.Add('Write', leIdentifier, leWrite);
  556.   KeyList.Add('Writeonly', leIdentifier, leWriteonly);
  557.  
  558.   {Additional}
  559.   DirectiveKeyList.Add('A', leA, leIdentifier);
  560.   DirectiveKeyList.Add('B', leB, leIdentifier);
  561.   DirectiveKeyList.Add('C', leC, leIdentifier);
  562.   DirectiveKeyList.Add('D', leD, leIdentifier);
  563.   DirectiveKeyList.Add('E', leE, leIdentifier);
  564.   DirectiveKeyList.Add('G', leG, leIdentifier);
  565.   DirectiveKeyList.Add('H', leH, leIdentifier);
  566.   DirectiveKeyList.Add('I', leI, leIdentifier);
  567.   DirectiveKeyList.Add('J', leJ, leIdentifier);
  568.   DirectiveKeyList.Add('L', leL, leIdentifier);
  569.   DirectiveKeyList.Add('M', leM, leIdentifier);
  570.   DirectiveKeyList.Add('O', leO, leIdentifier);
  571.   DirectiveKeyList.Add('P', leP, leIdentifier);
  572.   DirectiveKeyList.Add('Q', leQ, leIdentifier);
  573.   DirectiveKeyList.Add('R', leR, leIdentifier);
  574.   DirectiveKeyList.Add('T', leT, leIdentifier);
  575.   DirectiveKeyList.Add('U', leU, leIdentifier);
  576.   DirectiveKeyList.Add('V', leV, leIdentifier);
  577.   DirectiveKeyList.Add('W', leW, leIdentifier);
  578.   DirectiveKeyList.Add('X', leX, leIdentifier);
  579.   DirectiveKeyList.Add('Y', leY, leIdentifier);
  580.   DirectiveKeyList.Add('Z', leZ, leIdentifier);
  581.   DirectiveKeyList.Add('And', leAndDirective, leIdentifier);
  582.   DirectiveKeyList.Add('Off', leOff, leIdentifier);
  583.   DirectiveKeyList.Add('YD', leYD, leIdentifier);
  584.   DirectiveKeyList.Add('On', leOnDirective, leIdentifier);
  585.   DirectiveKeyList.Add('If', leIfDirective, leIdentifier);
  586.   DirectiveKeyList.Add('IfDef', leIfDef, leIdentifier);
  587.   DirectiveKeyList.Add('Or', leOrDirective, leIdentifier);
  588.   DirectiveKeyList.Add('GUI', leGUI, leIdentifier);
  589.   DirectiveKeyList.Add('EndIf', leEndIf, leIdentifier);
  590.   DirectiveKeyList.Add('IfEnd', leIfEnd, leIdentifier);
  591.   DirectiveKeyList.Add('Else', leElseDirective, leIdentifier);
  592.   DirectiveKeyList.Add('Define', leDefine, leIdentifier);
  593.   DirectiveKeyList.Add('Align', leAlign, leIdentifier);
  594.   DirectiveKeyList.Add('IfNDef', leIfNDef, leIdentifier);
  595.   DirectiveKeyList.Add('Link', leLink, leIdentifier);
  596.   DirectiveKeyList.Add('Defined', leDefined, leIdentifier);
  597.   DirectiveKeyList.Add('UnDef', leUnDef, leIdentifier);
  598.   DirectiveKeyList.Add('Declared', leDeclared, leIdentifier);
  599.   DirectiveKeyList.Add('ElseIf', leElseIf, leIdentifier);
  600.   DirectiveKeyList.Add('ImageBase', leImageBase, leIdentifier);
  601.   DirectiveKeyList.Add('IfOpt', leIfOpt, leIdentifier);
  602.   DirectiveKeyList.Add('SoName', leSoName, leIdentifier);
  603.   DirectiveKeyList.Add('Include', leInclude, leIdentifier);
  604.   DirectiveKeyList.Add('Hints', leHints, leIdentifier);
  605.   DirectiveKeyList.Add('NoDefine', leNoDefine, leIdentifier);
  606.   DirectiveKeyList.Add('IOChecks', leIOChecks, leIdentifier);
  607.   DirectiveKeyList.Add('DebugInfo', leDebugInfo, leIdentifier);
  608.   DirectiveKeyList.Add('Console', leConsole, leIdentifier);
  609.   DirectiveKeyList.Add('Booleval', leBooleval, leIdentifier);
  610.   DirectiveKeyList.Add('HPPEmit', leHPPEmit, leIdentifier);
  611.   DirectiveKeyList.Add('RangeChecks', leRangeChecks, leIdentifier);
  612.   DirectiveKeyList.Add('NoInclude', leNoInclude, leIdentifier);
  613.   DirectiveKeyList.Add('Apptype', leApptype, leIdentifier);
  614.   DirectiveKeyList.Add('SafeDivide', leSafeDivide, leIdentifier);
  615.   DirectiveKeyList.Add('Resource', leResource, leIdentifier);
  616.   DirectiveKeyList.Add('Warn', leWarn, leIdentifier);
  617.   DirectiveKeyList.Add('Warnings', leWarnings, leIdentifier);
  618.   DirectiveKeyList.Add('TypeInfo', leTypeInfo, leIdentifier);
  619.   DirectiveKeyList.Add('SetPEFlags', leSetPEFlags, leIdentifier);
  620.   DirectiveKeyList.Add('SoPrefix', leSoPrefix, leIdentifier);
  621.   DirectiveKeyList.Add('StackFrames', leStackFrames, leIdentifier);
  622.   DirectiveKeyList.Add('RunOnly', leRunOnly, leIdentifier);
  623.   DirectiveKeyList.Add('SoSuffix', leSoSuffix, leIdentifier);
  624.   DirectiveKeyList.Add('ReferenceInfo', leReferenceInfo, leIdentifier);
  625.   DirectiveKeyList.Add('DesignOnly', leDesignOnly, leIdentifier);
  626.   DirectiveKeyList.Add('Extension', leExtension, leIdentifier);
  627.   DirectiveKeyList.Add('ImportedData', leImportedData, leIdentifier);
  628.   DirectiveKeyList.Add('Description', leDescription, leIdentifier);
  629.   DirectiveKeyList.Add('SoVersion', leSoVersion, leIdentifier);
  630.   DirectiveKeyList.Add('Assertions', leAssertions, leIdentifier);
  631.   DirectiveKeyList.Add('ImplicitBuild', leImplicitBuild, leIdentifier);
  632.   DirectiveKeyList.Add('TypedAddress', leTypedAddress, leIdentifier);
  633.   DirectiveKeyList.Add('LocalSymbols', leLocalSymbols, leIdentifier);
  634.   DirectiveKeyList.Add('MinEnumSize', leMinEnumSize, leIdentifier);
  635.   DirectiveKeyList.Add('WeakPackageUnit', leWeakPackageUnit, leIdentifier);
  636.   DirectiveKeyList.Add('DefinitionInfo', leDefinitionInfo, leIdentifier);
  637.   DirectiveKeyList.Add('MinStackSize', leMinStackSize, leIdentifier);
  638.   DirectiveKeyList.Add('ObjExportAll', leObjExportAll, leIdentifier);
  639.   DirectiveKeyList.Add('MaxStackSize', leMaxStackSize, leIdentifier);
  640.   DirectiveKeyList.Add('LongStrings', leLongStrings, leIdentifier);
  641.   DirectiveKeyList.Add('DenyPackageUnit', leDenyPackageUnit, leIdentifier);
  642.   DirectiveKeyList.Add('ExternalSym', leExternalSym, leIdentifier);
  643.   DirectiveKeyList.Add('OpenStrings', leOpenStrings, leIdentifier);
  644.   DirectiveKeyList.Add('SetPEOptFlags', leSetPEOptFlags, leIdentifier);
  645.   DirectiveKeyList.Add('OverFlowChecks', leOverFlowChecks, leIdentifier);
  646.   DirectiveKeyList.Add('WriteableConst', leWriteableConst, leIdentifier);
  647.   DirectiveKeyList.Add('Optimization', leOptimization, leIdentifier);
  648.   DirectiveKeyList.Add('VarStringChecks', leVarStringChecks, leIdentifier);
  649.   DirectiveKeyList.Add('ExtendedSyntax', leExtendedSyntax, leIdentifier);
  650.   DirectiveKeyList.Add('RealCompatibility', leRealCompatibility, leIdentifier);
  651.   DirectiveKeyList.Add('ResourceReserve', leResourceReserve, leIdentifier);
  652.   DirectiveKeyList.Add('Region', leRegion, leIdentifier);
  653.   DirectiveKeyList.Add('EndRegion', leEndRegion, leIdentifier);
  654. end;
  655.  
  656. procedure TmwDelphiLexer.LessHandler;
  657. begin
  658.   inc(Run);
  659.   Id := leLess;
  660.   if Run < TheEnd then
  661.     case Buf[Run] of
  662.       '=':
  663.         begin
  664.           Id := leLessOrEqual;
  665.           inc(Run);
  666.         end;
  667.       '>':
  668.         begin
  669.           Id := leNotEqual;
  670.           inc(Run);
  671.         end;
  672.     end;
  673. end;
  674.  
  675. procedure TmwDelphiLexer.Next;
  676. begin
  677.   case Range of
  678.     drNormal: inherited Next;
  679.     drAnsiDirective: inherited Next;
  680.     drBorlandDirective: inherited Next;
  681.     drAssemblerReference: NextAssemblerReference;
  682.     drAnsiComment: NextAnsiComment;
  683.     drBorlandComment: NextBorlandComment;
  684.   end;
  685. end;
  686.  
  687. procedure TmwDelphiLexer.NextAnsiComment;
  688. begin
  689.   Start := Run;
  690.   ExId := leUnknown;
  691.   case Run < TheEnd of
  692.     True:
  693.       case Buf[Run] of
  694.         #10: LFHandler;
  695.         #13: CRHandler;
  696.       else
  697.         AnsiCommentHandler;
  698.       end;
  699.     False: Id := leAtEnd;
  700.   end
  701. end;
  702.  
  703. procedure TmwDelphiLexer.NextAssemblerReference;
  704. begin
  705.   Start := Run;
  706.   ExId := leUnknown;
  707.   case Run < TheEnd of
  708.     True:
  709.       case Buf[Run] of
  710.         #10: LFHandler;
  711.         #13: CRHandler;
  712.       else
  713.         AssemblerReferenceHandler;
  714.       end;
  715.     False: Id := leAtEnd;
  716.   end
  717. end;
  718.  
  719. procedure TmwDelphiLexer.NextBorlandComment;
  720. begin
  721.   Start := Run;
  722.   ExId := leUnknown;
  723.   case Run < TheEnd of
  724.     True:
  725.       case Buf[Run] of
  726.         #10: LFHandler;
  727.         #13: CRHandler;
  728.       else
  729.         BorlandCommentHandler;
  730.       end;
  731.     False: Id := leAtEnd;
  732.   end
  733. end;
  734.  
  735. procedure TmwDelphiLexer.PeriodHandler;
  736. begin
  737.   inc(Run);
  738.   Id := lePeriod;
  739.   if Run < TheEnd then
  740.     case Buf[Run] of
  741.       '.':
  742.         begin
  743.           inc(Run);
  744.           Id := leDotDot;
  745.         end;
  746.       ')':
  747.         begin
  748.           inc(Run);
  749.           Id := leSquareClose;
  750.         end;
  751.     end;
  752. end;
  753.  
  754. procedure TmwDelphiLexer.RoundOpenHandler;
  755. begin
  756.   inc(Run);
  757.   Id := leRoundOpen;
  758.   if Range = drNormal then
  759.     if Run < TheEnd then
  760.       case Buf[Run] of
  761.         '.':
  762.           begin
  763.             inc(Run);
  764.             Id := leSquareOpen;
  765.           end;
  766.         '*':
  767.           begin
  768.             inc(Run);
  769.             Id := leAnsiComment;
  770.             if Run < TheEnd then
  771.               case Buf[Run] = '$' of
  772.                 True:
  773.                   begin
  774.                     inc(Run);
  775.                     Range := drAnsiDirective;
  776.                     Id := leBeginOfAnsiDirective;
  777.                   end;
  778.                 False:
  779.                   begin
  780.                     Range := drAnsiComment;
  781.                     AnsiCommentHandler;
  782.                   end;
  783.               end;
  784.           end;
  785.       end;
  786. end;
  787.  
  788. procedure TmwDelphiLexer.SharpHandler;
  789. begin
  790.   inc(Run);
  791.   Id := leSharp;
  792.   if Run < TheEnd then
  793.     case Buf[Run] of
  794.       '$':
  795.         begin
  796.           inc(Run);
  797.           Id := leCharHexConstant;
  798.           while (Run < TheEnd) and
  799.             ((Buf[Run] >= '0') and (Buf[Run] <= '9')) or
  800.             ((Buf[Run] >= 'a') and (Buf[Run] <= 'f')) or
  801.             ((Buf[Run] >= 'A') and (Buf[Run] <= 'F')) do
  802.             inc(Run);
  803.         end;
  804.       '0'..'9':
  805.         begin
  806.           inc(Run);
  807.           Id := leCharConstant;
  808.           while (Run < TheEnd) and
  809.             ((Buf[Run] >= '0') and (Buf[Run] <= '9')) do
  810.             inc(Run);
  811.         end;
  812.     end;
  813. end;
  814.  
  815. procedure TmwDelphiLexer.SlashHandler;
  816. begin
  817.   inc(Run);
  818.   Id := leSlash;
  819.   if Range = drNormal then
  820.     case Run < TheEnd of
  821.       True:
  822.         if Buf[Run] = '/' then
  823.         begin
  824.           inc(Run);
  825.           Id := leSlashComment;
  826.           while Run < TheEnd do
  827.             case Buf[Run] of
  828.               #10: Break;
  829.               #13: case (Run < TheEnd) and (Buf[Run + 1] = #10) of
  830.                   True: Break;
  831.                   False: inc(Run);
  832.                 end;
  833.             else
  834.               inc(Run);
  835.             end;
  836.         end;
  837.     end;
  838. end;
  839.  
  840. end.
  841.  
  842.